home *** CD-ROM | disk | FTP | other *** search
/ MacTech 1 to 12 / MacTech-vol-1-12.toast / Source / MacTech® Magazine / Volume 05 - 1989 / 05.08 Aug 89 / POOPDraw Code ƒ / OBJT Group.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-06-12  |  6.3 KB  |  247 lines  |  [TEXT/KAHL]
  1.  
  2. /********************************************************************/
  3. /*                        SOURCE CODE FILE                            */
  4. /********************************************************************/
  5. /*
  6. *   >>>    File name:        6.2 GroupObject.c    
  7. *
  8. *      >>>    Purpose:        Methods for Group Object
  9. *     >>>    Project:        ObDraw    Version 1        
  10. *     >>>    Date:            2/20/89
  11. *      >>>    By:                Adam Treister
  12. *
  13. */
  14. /********************************************************************/
  15. /*    For Your Information            1802 Hillside Rd. SB CA 93101    */
  16. /********************************************************************/
  17.  
  18. #include "PoopDrawInc"
  19.  
  20. /***** Object Type Defs *********************************************/
  21. typedef struct
  22. {
  23.     _StdObjectFields
  24.     ObjectHandle list;
  25. }    GroupRec,*GroupPtr,**GroupHandle;
  26.  
  27. /***** Public Functions *********************************************/
  28.  
  29. GroupHandle NewGroup(void);
  30.  
  31. /***** Private Functions ********************************************/
  32.  
  33. private    void ObjDispatch(GroupHandle ObjectH,int Message,LPtr ParmP);
  34. private    void Dispose(GroupHandle ObjectH);
  35. private    void Ungroup(GroupHandle ObjectH);
  36. private    void Draw(GroupHandle ObjectH);
  37. private    void AddObjToGroup(GroupHandle ObjectH,ObjectHandle ParmP);
  38. private void Move(GroupHandle ObjectH,LPtr ParmP);
  39. private    void Pack(GroupHandle ObjectH,Handle h);
  40. private    void UnPack(GroupHandle ObjectH,Ptr *pP);
  41. private    void SetLength(GroupHandle ObjectH);
  42.  
  43. /********************************************************************/
  44.  
  45. void ObjDispatch(ObjectH,Message,ParmP)
  46. GroupHandle ObjectH;
  47. int Message;
  48. LPtr ParmP;
  49. {
  50.     switch(Message)
  51.     {
  52.         case DISPOSE:        Dispose(ObjectH);                                    break;
  53.         case ADDOBJECT:        AddObjToGroup(ObjectH,(ObjectHandle) ParmP);        break;        
  54.         case DRAW:            Draw(ObjectH);                                        break;
  55.         case MOVE:            Move(ObjectH,ParmP);                                break;
  56.         case UNGROUP:        Ungroup(ObjectH);                                    break;
  57.  
  58.         case SELECT:        BitSet(&(*ObjectH)->attributes,SelectedBit);    
  59.                             Dispatch(ObjectH,INVAL,NULL);                        break;
  60.          case UNSELECT:        BitClr(&(*ObjectH)->attributes,SelectedBit);
  61.                              Dispatch(ObjectH,INVAL,NULL);                        break;
  62.  
  63.         case FRAME:
  64.         case FILL:        
  65.         case PENPAT:        /* These Message are sent to all objects in the group */
  66.         case PENSIZE:        Dispatch((*ObjectH)->list,Message,ParmP);            break;
  67.  
  68.         case SETLEN:        SetLength(ObjectH);                    break;
  69.         case PACK:            Pack(ObjectH,ParmP);            break;
  70.         case UNPACK:        UnPack(ObjectH,ParmP);            break;
  71.  
  72.         default:            DrawObjectDispatch(ObjectH,Message,ParmP);
  73.     }
  74. }    
  75. /*-------------------------------------------NEW-----------------*/
  76. /*
  77. *    Function:            --    NewGroupObj
  78. *
  79. *    Date:                --    Feb. 20, 1989
  80. *    ObDraw Version 1    --     Copyright FYI,1989 --   Adam Treister
  81. /*---------------------------------------------------------------*/
  82.  
  83. GroupHandle NewGroup()
  84. {
  85.     GroupHandle ObjectH;
  86.     
  87.     ObjectH = _GetHandleToRecord(GroupRec);
  88.     NullOutHandle(ObjectH);
  89.     New(LIST,NULL,&(*ObjectH)->list);
  90.     SetRect(&(*ObjectH)->bounds,0,0,0,0);
  91.     BitSet(&(*ObjectH)->attributes,VisibleBit);    
  92.     (*ObjectH)->port = MyFrontWindow();
  93.     (*ObjectH)->dispatch = ObjDispatch;
  94.     (*ObjectH)->class = GROUP;
  95.     
  96.     Dispatch(ObjectH,INVAL,NULL);
  97.     return(ObjectH);
  98. }
  99. /*------------------------------------------------------------------*/
  100.  
  101. void Dispose(ObjectH)
  102. GroupHandle ObjectH;
  103. {
  104.         long KillItAll = 3;
  105.     Dispatch(SELF,INVAL,NULL);
  106.     WDispatch((*ObjectH)->port,DELOBJECT,SELF);
  107.     Dispatch((*ObjectH)->list,DISPOSE,&KillItAll);
  108.     DisposeHandle(ObjectH);
  109. }    
  110. /*------------------------------------------------------------------*/
  111.  
  112. void AddObjToGroup(ObjectH,newObj)
  113. GroupHandle ObjectH;
  114. ObjectHandle newObj;
  115. {
  116.     if (Width((*ObjectH)->bounds))
  117.         UnionRect(&(*ObjectH)->bounds,&(*newObj)->bounds,&(*ObjectH)->bounds);
  118.     else (*ObjectH)->bounds = (*newObj)->bounds;
  119.     Dispatch((*ObjectH)->list,ADDOBJECT,newObj);        
  120. }
  121. /*------------------------------------------------------------------*/
  122.  
  123. void Ungroup(ObjectH)
  124. GroupHandle ObjectH;
  125. {
  126. WindowPtr wP;
  127. int i;
  128. long nElems;
  129. ObjectHandle obj;
  130.  
  131.     wP = MyFrontWindow();
  132.     Dispatch((*ObjectH)->list,GETSIZE,&nElems);
  133.     for (i = 0; i <  nElems; i++)
  134.     {
  135.         Dispatch((*ObjectH)->list,NEXT,&obj);
  136.         Dispatch((*ObjectH)->list,DELOBJECT,obj);
  137.         WDispatch(wP,ADDOBJECT,obj);
  138.     }
  139.     WDispatch(wP,UNSELECT,SELF);
  140.     WDispatch(wP,DELOBJECT,SELF);
  141.     Dispose(ObjectH);
  142. }    
  143.  
  144. /*-------------------------------------------method--------------*/
  145. /*
  146. *    Function:            --    GroupDraw
  147. *
  148. *    Date:                --    Feb. 20, 1989
  149. *    ObDraw Version 1    --     Copyright FYI,1989 --   Adam Treister
  150. /*---------------------------------------------------------------*/
  151.  
  152. void Draw(ObjectH)
  153. GroupHandle ObjectH;
  154. {
  155.     if (BitTst(&(*ObjectH)->attributes,VisibleBit))
  156.     {
  157. /*         EraseRect(&(*ObjectH)->bounds);
  158.  */
  159.          Dispatch((*ObjectH)->list,DRAW,NULL);
  160.         if (BitTst(&(*ObjectH)->attributes,SelectedBit))
  161.         {
  162.             PenPat(gray);
  163.             PenSize(2,2);
  164.             FrameRect(&(*ObjectH)->bounds);
  165.         }
  166. }    }
  167. /*------------------------------------------------------------------*/
  168.  
  169. void Move(ObjectH,inP)
  170. GroupHandle ObjectH;
  171. LPtr inP;
  172. {
  173.     Point *ptP;
  174.     
  175.     Rect r;
  176.     r = (*ObjectH)->bounds;
  177.     InsetRect(&r,-2,-2);
  178.     EraseRect(&r);
  179.     InvalRect(&r);
  180.     ptP = (Point *) inP;
  181.     Dispatch((*ObjectH)->list,MOVE,inP);
  182.     OffsetRect(&(*ObjectH)->bounds,ptP->h,ptP->v);
  183.     InvalRect(&(*ObjectH)->bounds);
  184.  
  185. }    
  186. /*------------------------------------------------------------------*/
  187.  
  188. void SetLength(ObjectH)
  189. GroupHandle        ObjectH;
  190. {
  191.     long len;
  192.     
  193.     Dispatch((*ObjectH)->list,GETSIZE,&len);
  194.     (*ObjectH)->length = len;
  195. }
  196. /*------------------------------------------------------------------*/
  197. #define SKIP2FLDS  8L
  198. void Pack(ObjectH,h)
  199. GroupHandle        ObjectH;
  200. Handle h;    
  201. {
  202.         Size size;
  203.         Ptr p;
  204.         long nBytes;
  205.         Rect r;
  206.     
  207.     nBytes = _lsizeof(ObjectRec) - SKIP2FLDS;
  208.     size = GetHandleSize(h);
  209.     SetHandleSize(h,size + nBytes);        MEM_CHECK
  210.     
  211.     HLock(h);
  212.     p = *h + size;                    /* move to end of existing handle */
  213.     BlockMove(&(*ObjectH)->class,p,nBytes);    
  214.     HUnlock(h);
  215.     
  216.     Dispatch((*ObjectH)->list,SETLEN,h);
  217.     Dispatch((*ObjectH)->list,PACK,h);
  218. }
  219. /*------------------------------------------------------------------*/
  220. void UnPack(ObjectH,pP)
  221. GroupHandle ObjectH;
  222. Ptr *pP;    
  223. {
  224.         Ptr p;
  225.         int nObjects,i;
  226.         long nBytes;
  227.          Rect dummyRect;
  228.          ObjectHandle NewObject;
  229.         int class;
  230.  
  231.     nBytes = _lsizeof(ObjectRec) - SKIP2FLDS;
  232.     p = *pP;
  233.     BlockMove(p,&(*ObjectH)->class,nBytes);    
  234.     nObjects = (*ObjectH)->length;                
  235.     *pP += nBytes;
  236.     SetRect(&dummyRect,0,0,1,1);
  237.     for (i = 0; i < nObjects ; i++)
  238.     {
  239.         class = *(int *) (*pP);
  240.         New(class,&dummyRect,&NewObject);
  241.         Dispatch(NewObject,UNPACK,pP);
  242.         Dispatch((*ObjectH)->list,ADDOBJECT,NewObject);
  243.     }    
  244.     
  245. }
  246.  
  247.